package Test.PracticeCAS;

import java.util.concurrent.CountDownLatch;


public class demo02 {
    static int count=0;

    public synchronized static void request() throws InterruptedException {

        Thread.sleep(5);
        /**
         * Q：耗时太长的原因？
         * A：
         *      1.程序中的 synchronized 保证了这个方法同一时刻只有一个线程进入；
         *      这样虽然让count的值一定正确，但却延长了执行的时间
         *      那么如果解决的运行时间长的问题呢？
         *              解决方法就是把锁加到第三步，也就是 把加好的值返回给count的这一步加锁
         *
         *              原来版本的三步：
         *              1.获取count值
         *              2.讲count值+1
         *              3.将这个值返回给count
         *
         *              现在把第三步修改为：
         *                  1.获取锁
         *                  2.获取现在最新的值
         *                  3.判断最新的值，是否等于原来的值；如果相等，把结果返回给count
         *                  4.释放锁
         */
        count++;
    }

    public static void main(String[] args) throws InterruptedException {

        long startTime=System.currentTimeMillis();
        int size=100;
        CountDownLatch countDownLatch=new CountDownLatch(size);

        for (int i = 0; i < size; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try{
                        for (int j = 0; j < 10; j++) {
                            request();
                        }
                    }catch (Exception e){
                        e.printStackTrace();
                    }finally {
                        countDownLatch.countDown();
                    }

                }
            }).start();
        }

        countDownLatch.await();
        long endTime=System.currentTimeMillis();

        System.out.println(endTime-startTime);
        System.out.println(count);
    }

}